From d8d07e78c2cbace2422e2b565585d55573f93f34 Mon Sep 17 00:00:00 2001 From: parkrrrr Date: Mon, 12 Jan 2004 15:30:18 +0000 Subject: [PATCH] Initial add --- gpsbabel/msvc/Expat/expat.h | 1001 ++++++++++++++++++++++++++++++ gpsbabel/msvc/Expat/libexpat.dll | Bin 0 -> 143360 bytes gpsbabel/msvc/Expat/libexpat.lib | Bin 0 -> 16816 bytes gpsbabel/msvc/GPSBabel.dsp | 617 ++++++++++++++++++ gpsbabel/msvc/GPSBabel.dsw | 29 + 5 files changed, 1647 insertions(+) create mode 100644 gpsbabel/msvc/Expat/expat.h create mode 100755 gpsbabel/msvc/Expat/libexpat.dll create mode 100644 gpsbabel/msvc/Expat/libexpat.lib create mode 100644 gpsbabel/msvc/GPSBabel.dsp create mode 100644 gpsbabel/msvc/GPSBabel.dsw diff --git a/gpsbabel/msvc/Expat/expat.h b/gpsbabel/msvc/Expat/expat.h new file mode 100644 index 000000000..99678856d --- /dev/null +++ b/gpsbabel/msvc/Expat/expat.h @@ -0,0 +1,1001 @@ +/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd + See the file COPYING for copying permission. +*/ + +#ifndef XmlParse_INCLUDED +#define XmlParse_INCLUDED 1 + +#ifdef __VMS +/* 0 1 2 3 0 1 2 3 + 1234567890123456789012345678901 1234567890123456789012345678901 */ +#define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler +#define XML_SetUnparsedEntityDeclHandler XML_SetUnparsedEntDeclHandler +#define XML_SetStartNamespaceDeclHandler XML_SetStartNamespcDeclHandler +#define XML_SetExternalEntityRefHandlerArg XML_SetExternalEntRefHandlerArg +#endif + +#include + +#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__) +#define XML_USE_MSC_EXTENSIONS 1 +#endif + +/* Expat tries very hard to make the API boundary very specifically + defined. There are two macros defined to control this boundary; + each of these can be defined before including this header to + achieve some different behavior, but doing so it not recommended or + tested frequently. + + XMLCALL - The calling convention to use for all calls across the + "library boundary." This will default to cdecl, and + try really hard to tell the compiler that's what we + want. + + XMLIMPORT - Whatever magic is needed to note that a function is + to be imported from a dynamically loaded library + (.dll, .so, or .sl, depending on your platform). + + The XMLCALL macro was added in Expat 1.95.7. The only one which is + expected to be directly useful in client code is XMLCALL. + + Note that on at least some Unix versions, the Expat library must be + compiled with the cdecl calling convention as the default since + system headers may assume the cdecl convention. +*/ +#ifndef XMLCALL +#if defined(XML_USE_MSC_EXTENSIONS) +#define XMLCALL __cdecl +#elif defined(__GNUC__) +#define XMLCALL __attribute__((cdecl)) +#else +/* For any platform which uses this definition and supports more than + one calling convention, we need to extend this definition to + declare the convention used on that platform, if it's possible to + do so. + + If this is the case for your platform, please file a bug report + with information on how to identify your platform via the C + pre-processor and how to specify the same calling convention as the + platform's malloc() implementation. +*/ +#define XMLCALL +#endif +#endif /* not defined XMLCALL */ + + +#if !defined(XML_STATIC) && !defined(XMLIMPORT) +#ifndef XML_BUILDING_EXPAT +/* using Expat from an application */ + +#ifdef XML_USE_MSC_EXTENSIONS +#define XMLIMPORT __declspec(dllimport) +#endif + +#endif +#endif /* not defined XML_STATIC */ + +/* If we didn't define it above, define it away: */ +#ifndef XMLIMPORT +#define XMLIMPORT +#endif + + +#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef XML_UNICODE_WCHAR_T +#define XML_UNICODE +#endif + +struct XML_ParserStruct; +typedef struct XML_ParserStruct *XML_Parser; + +#ifdef XML_UNICODE /* Information is UTF-16 encoded. */ +#ifdef XML_UNICODE_WCHAR_T +typedef wchar_t XML_Char; +typedef wchar_t XML_LChar; +#else +typedef unsigned short XML_Char; +typedef char XML_LChar; +#endif /* XML_UNICODE_WCHAR_T */ +#else /* Information is UTF-8 encoded. */ +typedef char XML_Char; +typedef char XML_LChar; +#endif /* XML_UNICODE */ + +/* Should this be defined using stdbool.h when C99 is available? */ +typedef unsigned char XML_Bool; +#define XML_TRUE ((XML_Bool) 1) +#define XML_FALSE ((XML_Bool) 0) + +/* The XML_Status enum gives the possible return values for several + API functions. The preprocessor #defines are included so this + stanza can be added to code that still needs to support older + versions of Expat 1.95.x: + + #ifndef XML_STATUS_OK + #define XML_STATUS_OK 1 + #define XML_STATUS_ERROR 0 + #endif + + Otherwise, the #define hackery is quite ugly and would have been + dropped. +*/ +enum XML_Status { + XML_STATUS_ERROR = 0, +#define XML_STATUS_ERROR XML_STATUS_ERROR + XML_STATUS_OK = 1 +#define XML_STATUS_OK XML_STATUS_OK +}; + +enum XML_Error { + XML_ERROR_NONE, + XML_ERROR_NO_MEMORY, + XML_ERROR_SYNTAX, + XML_ERROR_NO_ELEMENTS, + XML_ERROR_INVALID_TOKEN, + XML_ERROR_UNCLOSED_TOKEN, + XML_ERROR_PARTIAL_CHAR, + XML_ERROR_TAG_MISMATCH, + XML_ERROR_DUPLICATE_ATTRIBUTE, + XML_ERROR_JUNK_AFTER_DOC_ELEMENT, + XML_ERROR_PARAM_ENTITY_REF, + XML_ERROR_UNDEFINED_ENTITY, + XML_ERROR_RECURSIVE_ENTITY_REF, + XML_ERROR_ASYNC_ENTITY, + XML_ERROR_BAD_CHAR_REF, + XML_ERROR_BINARY_ENTITY_REF, + XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, + XML_ERROR_MISPLACED_XML_PI, + XML_ERROR_UNKNOWN_ENCODING, + XML_ERROR_INCORRECT_ENCODING, + XML_ERROR_UNCLOSED_CDATA_SECTION, + XML_ERROR_EXTERNAL_ENTITY_HANDLING, + XML_ERROR_NOT_STANDALONE, + XML_ERROR_UNEXPECTED_STATE, + XML_ERROR_ENTITY_DECLARED_IN_PE, + XML_ERROR_FEATURE_REQUIRES_XML_DTD, + XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING, + XML_ERROR_UNBOUND_PREFIX +}; + +enum XML_Content_Type { + XML_CTYPE_EMPTY = 1, + XML_CTYPE_ANY, + XML_CTYPE_MIXED, + XML_CTYPE_NAME, + XML_CTYPE_CHOICE, + XML_CTYPE_SEQ +}; + +enum XML_Content_Quant { + XML_CQUANT_NONE, + XML_CQUANT_OPT, + XML_CQUANT_REP, + XML_CQUANT_PLUS +}; + +/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be + XML_CQUANT_NONE, and the other fields will be zero or NULL. + If type == XML_CTYPE_MIXED, then quant will be NONE or REP and + numchildren will contain number of elements that may be mixed in + and children point to an array of XML_Content cells that will be + all of XML_CTYPE_NAME type with no quantification. + + If type == XML_CTYPE_NAME, then the name points to the name, and + the numchildren field will be zero and children will be NULL. The + quant fields indicates any quantifiers placed on the name. + + CHOICE and SEQ will have name NULL, the number of children in + numchildren and children will point, recursively, to an array + of XML_Content cells. + + The EMPTY, ANY, and MIXED types will only occur at top level. +*/ + +typedef struct XML_cp XML_Content; + +struct XML_cp { + enum XML_Content_Type type; + enum XML_Content_Quant quant; + XML_Char * name; + unsigned int numchildren; + XML_Content * children; +}; + + +/* This is called for an element declaration. See above for + description of the model argument. It's the caller's responsibility + to free model when finished with it. +*/ +typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData, + const XML_Char *name, + XML_Content *model); + +XMLPARSEAPI(void) +XML_SetElementDeclHandler(XML_Parser parser, + XML_ElementDeclHandler eldecl); + +/* The Attlist declaration handler is called for *each* attribute. So + a single Attlist declaration with multiple attributes declared will + generate multiple calls to this handler. The "default" parameter + may be NULL in the case of the "#IMPLIED" or "#REQUIRED" + keyword. The "isrequired" parameter will be true and the default + value will be NULL in the case of "#REQUIRED". If "isrequired" is + true and default is non-NULL, then this is a "#FIXED" default. +*/ +typedef void (XMLCALL *XML_AttlistDeclHandler) ( + void *userData, + const XML_Char *elname, + const XML_Char *attname, + const XML_Char *att_type, + const XML_Char *dflt, + int isrequired); + +XMLPARSEAPI(void) +XML_SetAttlistDeclHandler(XML_Parser parser, + XML_AttlistDeclHandler attdecl); + +/* The XML declaration handler is called for *both* XML declarations + and text declarations. The way to distinguish is that the version + parameter will be NULL for text declarations. The encoding + parameter may be NULL for XML declarations. The standalone + parameter will be -1, 0, or 1 indicating respectively that there + was no standalone parameter in the declaration, that it was given + as no, or that it was given as yes. +*/ +typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData, + const XML_Char *version, + const XML_Char *encoding, + int standalone); + +XMLPARSEAPI(void) +XML_SetXmlDeclHandler(XML_Parser parser, + XML_XmlDeclHandler xmldecl); + + +typedef struct { + void *(XMLCALL *malloc_fcn)(size_t size); + void *(XMLCALL *realloc_fcn)(void *ptr, size_t size); + void (XMLCALL *free_fcn)(void *ptr); +} XML_Memory_Handling_Suite; + +/* Constructs a new parser; encoding is the encoding specified by the + external protocol or NULL if there is none specified. +*/ +XMLPARSEAPI(XML_Parser) +XML_ParserCreate(const XML_Char *encoding); + +/* Constructs a new parser and namespace processor. Element type + names and attribute names that belong to a namespace will be + expanded; unprefixed attribute names are never expanded; unprefixed + element type names are expanded only if there is a default + namespace. The expanded name is the concatenation of the namespace + URI, the namespace separator character, and the local part of the + name. If the namespace separator is '\0' then the namespace URI + and the local part will be concatenated without any separator. + When a namespace is not declared, the name and prefix will be + passed through without expansion. +*/ +XMLPARSEAPI(XML_Parser) +XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator); + + +/* Constructs a new parser using the memory management suite referred to + by memsuite. If memsuite is NULL, then use the standard library memory + suite. If namespaceSeparator is non-NULL it creates a parser with + namespace processing as described above. The character pointed at + will serve as the namespace separator. + + All further memory operations used for the created parser will come from + the given suite. +*/ +XMLPARSEAPI(XML_Parser) +XML_ParserCreate_MM(const XML_Char *encoding, + const XML_Memory_Handling_Suite *memsuite, + const XML_Char *namespaceSeparator); + +/* Prepare a parser object to be re-used. This is particularly + valuable when memory allocation overhead is disproportionatly high, + such as when a large number of small documnents need to be parsed. + All handlers are cleared from the parser, except for the + unknownEncodingHandler. The parser's external state is re-initialized + except for the values of ns and ns_triplets. + + Added in Expat 1.95.3. +*/ +XMLPARSEAPI(XML_Bool) +XML_ParserReset(XML_Parser parser, const XML_Char *encoding); + +/* atts is array of name/value pairs, terminated by 0; + names and values are 0 terminated. +*/ +typedef void (XMLCALL *XML_StartElementHandler) (void *userData, + const XML_Char *name, + const XML_Char **atts); + +typedef void (XMLCALL *XML_EndElementHandler) (void *userData, + const XML_Char *name); + + +/* s is not 0 terminated. */ +typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData, + const XML_Char *s, + int len); + +/* target and data are 0 terminated */ +typedef void (XMLCALL *XML_ProcessingInstructionHandler) ( + void *userData, + const XML_Char *target, + const XML_Char *data); + +/* data is 0 terminated */ +typedef void (XMLCALL *XML_CommentHandler) (void *userData, + const XML_Char *data); + +typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData); +typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData); + +/* This is called for any characters in the XML document for which + there is no applicable handler. This includes both characters that + are part of markup which is of a kind that is not reported + (comments, markup declarations), or characters that are part of a + construct which could be reported but for which no handler has been + supplied. The characters are passed exactly as they were in the XML + document except that they will be encoded in UTF-8 or UTF-16. + Line boundaries are not normalized. Note that a byte order mark + character is not passed to the default handler. There are no + guarantees about how characters are divided between calls to the + default handler: for example, a comment might be split between + multiple calls. +*/ +typedef void (XMLCALL *XML_DefaultHandler) (void *userData, + const XML_Char *s, + int len); + +/* This is called for the start of the DOCTYPE declaration, before + any DTD or internal subset is parsed. +*/ +typedef void (XMLCALL *XML_StartDoctypeDeclHandler) ( + void *userData, + const XML_Char *doctypeName, + const XML_Char *sysid, + const XML_Char *pubid, + int has_internal_subset); + +/* This is called for the start of the DOCTYPE declaration when the + closing > is encountered, but after processing any external + subset. +*/ +typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData); + +/* This is called for entity declarations. The is_parameter_entity + argument will be non-zero if the entity is a parameter entity, zero + otherwise. + + For internal entities (), value will + be non-NULL and systemId, publicID, and notationName will be NULL. + The value string is NOT nul-terminated; the length is provided in + the value_length argument. Since it is legal to have zero-length + values, do not use this argument to test for internal entities. + + For external entities, value will be NULL and systemId will be + non-NULL. The publicId argument will be NULL unless a public + identifier was provided. The notationName argument will have a + non-NULL value only for unparsed entity declarations. + + Note that is_parameter_entity can't be changed to XML_Bool, since + that would break binary compatibility. +*/ +typedef void (XMLCALL *XML_EntityDeclHandler) ( + void *userData, + const XML_Char *entityName, + int is_parameter_entity, + const XML_Char *value, + int value_length, + const XML_Char *base, + const XML_Char *systemId, + const XML_Char *publicId, + const XML_Char *notationName); + +XMLPARSEAPI(void) +XML_SetEntityDeclHandler(XML_Parser parser, + XML_EntityDeclHandler handler); + +/* OBSOLETE -- OBSOLETE -- OBSOLETE + This handler has been superceded by the EntityDeclHandler above. + It is provided here for backward compatibility. + + This is called for a declaration of an unparsed (NDATA) entity. + The base argument is whatever was set by XML_SetBase. The + entityName, systemId and notationName arguments will never be + NULL. The other arguments may be. +*/ +typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) ( + void *userData, + const XML_Char *entityName, + const XML_Char *base, + const XML_Char *systemId, + const XML_Char *publicId, + const XML_Char *notationName); + +/* This is called for a declaration of notation. The base argument is + whatever was set by XML_SetBase. The notationName will never be + NULL. The other arguments can be. +*/ +typedef void (XMLCALL *XML_NotationDeclHandler) ( + void *userData, + const XML_Char *notationName, + const XML_Char *base, + const XML_Char *systemId, + const XML_Char *publicId); + +/* When namespace processing is enabled, these are called once for + each namespace declaration. The call to the start and end element + handlers occur between the calls to the start and end namespace + declaration handlers. For an xmlns attribute, prefix will be + NULL. For an xmlns="" attribute, uri will be NULL. +*/ +typedef void (XMLCALL *XML_StartNamespaceDeclHandler) ( + void *userData, + const XML_Char *prefix, + const XML_Char *uri); + +typedef void (XMLCALL *XML_EndNamespaceDeclHandler) ( + void *userData, + const XML_Char *prefix); + +/* This is called if the document is not standalone, that is, it has an + external subset or a reference to a parameter entity, but does not + have standalone="yes". If this handler returns XML_STATUS_ERROR, + then processing will not continue, and the parser will return a + XML_ERROR_NOT_STANDALONE error. + If parameter entity parsing is enabled, then in addition to the + conditions above this handler will only be called if the referenced + entity was actually read. +*/ +typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData); + +/* This is called for a reference to an external parsed general + entity. The referenced entity is not automatically parsed. The + application can parse it immediately or later using + XML_ExternalEntityParserCreate. + + The parser argument is the parser parsing the entity containing the + reference; it can be passed as the parser argument to + XML_ExternalEntityParserCreate. The systemId argument is the + system identifier as specified in the entity declaration; it will + not be NULL. + + The base argument is the system identifier that should be used as + the base for resolving systemId if systemId was relative; this is + set by XML_SetBase; it may be NULL. + + The publicId argument is the public identifier as specified in the + entity declaration, or NULL if none was specified; the whitespace + in the public identifier will have been normalized as required by + the XML spec. + + The context argument specifies the parsing context in the format + expected by the context argument to XML_ExternalEntityParserCreate; + context is valid only until the handler returns, so if the + referenced entity is to be parsed later, it must be copied. + context is NULL only when the entity is a parameter entity. + + The handler should return XML_STATUS_ERROR if processing should not + continue because of a fatal error in the handling of the external + entity. In this case the calling parser will return an + XML_ERROR_EXTERNAL_ENTITY_HANDLING error. + + Note that unlike other handlers the first argument is the parser, + not userData. +*/ +typedef int (XMLCALL *XML_ExternalEntityRefHandler) ( + XML_Parser parser, + const XML_Char *context, + const XML_Char *base, + const XML_Char *systemId, + const XML_Char *publicId); + +/* This is called in two situations: + 1) An entity reference is encountered for which no declaration + has been read *and* this is not an error. + 2) An internal entity reference is read, but not expanded, because + XML_SetDefaultHandler has been called. + Note: skipped parameter entities in declarations and skipped general + entities in attribute values cannot be reported, because + the event would be out of sync with the reporting of the + declarations or attribute values +*/ +typedef void (XMLCALL *XML_SkippedEntityHandler) ( + void *userData, + const XML_Char *entityName, + int is_parameter_entity); + +/* This structure is filled in by the XML_UnknownEncodingHandler to + provide information to the parser about encodings that are unknown + to the parser. + + The map[b] member gives information about byte sequences whose + first byte is b. + + If map[b] is c where c is >= 0, then b by itself encodes the + Unicode scalar value c. + + If map[b] is -1, then the byte sequence is malformed. + + If map[b] is -n, where n >= 2, then b is the first byte of an + n-byte sequence that encodes a single Unicode scalar value. + + The data member will be passed as the first argument to the convert + function. + + The convert function is used to convert multibyte sequences; s will + point to a n-byte sequence where map[(unsigned char)*s] == -n. The + convert function must return the Unicode scalar value represented + by this byte sequence or -1 if the byte sequence is malformed. + + The convert function may be NULL if the encoding is a single-byte + encoding, that is if map[b] >= -1 for all bytes b. + + When the parser is finished with the encoding, then if release is + not NULL, it will call release passing it the data member; once + release has been called, the convert function will not be called + again. + + Expat places certain restrictions on the encodings that are supported + using this mechanism. + + 1. Every ASCII character that can appear in a well-formed XML document, + other than the characters + + $@\^`{}~ + + must be represented by a single byte, and that byte must be the + same byte that represents that character in ASCII. + + 2. No character may require more than 4 bytes to encode. + + 3. All characters encoded must have Unicode scalar values <= + 0xFFFF, (i.e., characters that would be encoded by surrogates in + UTF-16 are not allowed). Note that this restriction doesn't + apply to the built-in support for UTF-8 and UTF-16. + + 4. No Unicode character may be encoded by more than one distinct + sequence of bytes. +*/ +typedef struct { + int map[256]; + void *data; + int (XMLCALL *convert)(void *data, const char *s); + void (XMLCALL *release)(void *data); +} XML_Encoding; + +/* This is called for an encoding that is unknown to the parser. + + The encodingHandlerData argument is that which was passed as the + second argument to XML_SetUnknownEncodingHandler. + + The name argument gives the name of the encoding as specified in + the encoding declaration. + + If the callback can provide information about the encoding, it must + fill in the XML_Encoding structure, and return XML_STATUS_OK. + Otherwise it must return XML_STATUS_ERROR. + + If info does not describe a suitable encoding, then the parser will + return an XML_UNKNOWN_ENCODING error. +*/ +typedef int (XMLCALL *XML_UnknownEncodingHandler) ( + void *encodingHandlerData, + const XML_Char *name, + XML_Encoding *info); + +XMLPARSEAPI(void) +XML_SetElementHandler(XML_Parser parser, + XML_StartElementHandler start, + XML_EndElementHandler end); + +XMLPARSEAPI(void) +XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler); + +XMLPARSEAPI(void) +XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler); + +XMLPARSEAPI(void) +XML_SetCharacterDataHandler(XML_Parser parser, + XML_CharacterDataHandler handler); + +XMLPARSEAPI(void) +XML_SetProcessingInstructionHandler(XML_Parser parser, + XML_ProcessingInstructionHandler handler); +XMLPARSEAPI(void) +XML_SetCommentHandler(XML_Parser parser, + XML_CommentHandler handler); + +XMLPARSEAPI(void) +XML_SetCdataSectionHandler(XML_Parser parser, + XML_StartCdataSectionHandler start, + XML_EndCdataSectionHandler end); + +XMLPARSEAPI(void) +XML_SetStartCdataSectionHandler(XML_Parser parser, + XML_StartCdataSectionHandler start); + +XMLPARSEAPI(void) +XML_SetEndCdataSectionHandler(XML_Parser parser, + XML_EndCdataSectionHandler end); + +/* This sets the default handler and also inhibits expansion of + internal entities. These entity references will be passed to the + default handler, or to the skipped entity handler, if one is set. +*/ +XMLPARSEAPI(void) +XML_SetDefaultHandler(XML_Parser parser, + XML_DefaultHandler handler); + +/* This sets the default handler but does not inhibit expansion of + internal entities. The entity reference will not be passed to the + default handler. +*/ +XMLPARSEAPI(void) +XML_SetDefaultHandlerExpand(XML_Parser parser, + XML_DefaultHandler handler); + +XMLPARSEAPI(void) +XML_SetDoctypeDeclHandler(XML_Parser parser, + XML_StartDoctypeDeclHandler start, + XML_EndDoctypeDeclHandler end); + +XMLPARSEAPI(void) +XML_SetStartDoctypeDeclHandler(XML_Parser parser, + XML_StartDoctypeDeclHandler start); + +XMLPARSEAPI(void) +XML_SetEndDoctypeDeclHandler(XML_Parser parser, + XML_EndDoctypeDeclHandler end); + +XMLPARSEAPI(void) +XML_SetUnparsedEntityDeclHandler(XML_Parser parser, + XML_UnparsedEntityDeclHandler handler); + +XMLPARSEAPI(void) +XML_SetNotationDeclHandler(XML_Parser parser, + XML_NotationDeclHandler handler); + +XMLPARSEAPI(void) +XML_SetNamespaceDeclHandler(XML_Parser parser, + XML_StartNamespaceDeclHandler start, + XML_EndNamespaceDeclHandler end); + +XMLPARSEAPI(void) +XML_SetStartNamespaceDeclHandler(XML_Parser parser, + XML_StartNamespaceDeclHandler start); + +XMLPARSEAPI(void) +XML_SetEndNamespaceDeclHandler(XML_Parser parser, + XML_EndNamespaceDeclHandler end); + +XMLPARSEAPI(void) +XML_SetNotStandaloneHandler(XML_Parser parser, + XML_NotStandaloneHandler handler); + +XMLPARSEAPI(void) +XML_SetExternalEntityRefHandler(XML_Parser parser, + XML_ExternalEntityRefHandler handler); + +/* If a non-NULL value for arg is specified here, then it will be + passed as the first argument to the external entity ref handler + instead of the parser object. +*/ +XMLPARSEAPI(void) +XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg); + +XMLPARSEAPI(void) +XML_SetSkippedEntityHandler(XML_Parser parser, + XML_SkippedEntityHandler handler); + +XMLPARSEAPI(void) +XML_SetUnknownEncodingHandler(XML_Parser parser, + XML_UnknownEncodingHandler handler, + void *encodingHandlerData); + +/* This can be called within a handler for a start element, end + element, processing instruction or character data. It causes the + corresponding markup to be passed to the default handler. +*/ +XMLPARSEAPI(void) +XML_DefaultCurrent(XML_Parser parser); + +/* If do_nst is non-zero, and namespace processing is in effect, and + a name has a prefix (i.e. an explicit namespace qualifier) then + that name is returned as a triplet in a single string separated by + the separator character specified when the parser was created: URI + + sep + local_name + sep + prefix. + + If do_nst is zero, then namespace information is returned in the + default manner (URI + sep + local_name) whether or not the name + has a prefix. + + Note: Calling XML_SetReturnNSTriplet after XML_Parse or + XML_ParseBuffer has no effect. +*/ + +XMLPARSEAPI(void) +XML_SetReturnNSTriplet(XML_Parser parser, int do_nst); + +/* This value is passed as the userData argument to callbacks. */ +XMLPARSEAPI(void) +XML_SetUserData(XML_Parser parser, void *userData); + +/* Returns the last value set by XML_SetUserData or NULL. */ +#define XML_GetUserData(parser) (*(void **)(parser)) + +/* This is equivalent to supplying an encoding argument to + XML_ParserCreate. On success XML_SetEncoding returns non-zero, + zero otherwise. + Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer + has no effect and returns XML_STATUS_ERROR. +*/ +XMLPARSEAPI(enum XML_Status) +XML_SetEncoding(XML_Parser parser, const XML_Char *encoding); + +/* If this function is called, then the parser will be passed as the + first argument to callbacks instead of userData. The userData will + still be accessible using XML_GetUserData. +*/ +XMLPARSEAPI(void) +XML_UseParserAsHandlerArg(XML_Parser parser); + +/* If useDTD == XML_TRUE is passed to this function, then the parser + will assume that there is an external subset, even if none is + specified in the document. In such a case the parser will call the + externalEntityRefHandler with a value of NULL for the systemId + argument (the publicId and context arguments will be NULL as well). + Note: If this function is called, then this must be done before + the first call to XML_Parse or XML_ParseBuffer, since it will + have no effect after that. Returns + XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING. + Note: If the document does not have a DOCTYPE declaration at all, + then startDoctypeDeclHandler and endDoctypeDeclHandler will not + be called, despite an external subset being parsed. + Note: If XML_DTD is not defined when Expat is compiled, returns + XML_ERROR_FEATURE_REQUIRES_XML_DTD. +*/ +XMLPARSEAPI(enum XML_Error) +XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD); + + +/* Sets the base to be used for resolving relative URIs in system + identifiers in declarations. Resolving relative identifiers is + left to the application: this value will be passed through as the + base argument to the XML_ExternalEntityRefHandler, + XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base + argument will be copied. Returns XML_STATUS_ERROR if out of memory, + XML_STATUS_OK otherwise. +*/ +XMLPARSEAPI(enum XML_Status) +XML_SetBase(XML_Parser parser, const XML_Char *base); + +XMLPARSEAPI(const XML_Char *) +XML_GetBase(XML_Parser parser); + +/* Returns the number of the attribute/value pairs passed in last call + to the XML_StartElementHandler that were specified in the start-tag + rather than defaulted. Each attribute/value pair counts as 2; thus + this correspondds to an index into the atts array passed to the + XML_StartElementHandler. +*/ +XMLPARSEAPI(int) +XML_GetSpecifiedAttributeCount(XML_Parser parser); + +/* Returns the index of the ID attribute passed in the last call to + XML_StartElementHandler, or -1 if there is no ID attribute. Each + attribute/value pair counts as 2; thus this correspondds to an + index into the atts array passed to the XML_StartElementHandler. +*/ +XMLPARSEAPI(int) +XML_GetIdAttributeIndex(XML_Parser parser); + +/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is + detected. The last call to XML_Parse must have isFinal true; len + may be zero for this call (or any other). + + Though the return values for these functions has always been + described as a Boolean value, the implementation, at least for the + 1.95.x series, has always returned exactly one of the XML_Status + values. +*/ +XMLPARSEAPI(enum XML_Status) +XML_Parse(XML_Parser parser, const char *s, int len, int isFinal); + +XMLPARSEAPI(void *) +XML_GetBuffer(XML_Parser parser, int len); + +XMLPARSEAPI(enum XML_Status) +XML_ParseBuffer(XML_Parser parser, int len, int isFinal); + +/* Creates an XML_Parser object that can parse an external general + entity; context is a '\0'-terminated string specifying the parse + context; encoding is a '\0'-terminated string giving the name of + the externally specified encoding, or NULL if there is no + externally specified encoding. The context string consists of a + sequence of tokens separated by formfeeds (\f); a token consisting + of a name specifies that the general entity of the name is open; a + token of the form prefix=uri specifies the namespace for a + particular prefix; a token of the form =uri specifies the default + namespace. This can be called at any point after the first call to + an ExternalEntityRefHandler so longer as the parser has not yet + been freed. The new parser is completely independent and may + safely be used in a separate thread. The handlers and userData are + initialized from the parser argument. Returns NULL if out of memory. + Otherwise returns a new XML_Parser object. +*/ +XMLPARSEAPI(XML_Parser) +XML_ExternalEntityParserCreate(XML_Parser parser, + const XML_Char *context, + const XML_Char *encoding); + +enum XML_ParamEntityParsing { + XML_PARAM_ENTITY_PARSING_NEVER, + XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE, + XML_PARAM_ENTITY_PARSING_ALWAYS +}; + +/* Controls parsing of parameter entities (including the external DTD + subset). If parsing of parameter entities is enabled, then + references to external parameter entities (including the external + DTD subset) will be passed to the handler set with + XML_SetExternalEntityRefHandler. The context passed will be 0. + + Unlike external general entities, external parameter entities can + only be parsed synchronously. If the external parameter entity is + to be parsed, it must be parsed during the call to the external + entity ref handler: the complete sequence of + XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and + XML_ParserFree calls must be made during this call. After + XML_ExternalEntityParserCreate has been called to create the parser + for the external parameter entity (context must be 0 for this + call), it is illegal to make any calls on the old parser until + XML_ParserFree has been called on the newly created parser. + If the library has been compiled without support for parameter + entity parsing (ie without XML_DTD being defined), then + XML_SetParamEntityParsing will return 0 if parsing of parameter + entities is requested; otherwise it will return non-zero. + Note: If XML_SetParamEntityParsing is called after XML_Parse or + XML_ParseBuffer, then it has no effect and will always return 0. +*/ +XMLPARSEAPI(int) +XML_SetParamEntityParsing(XML_Parser parser, + enum XML_ParamEntityParsing parsing); + +/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then + XML_GetErrorCode returns information about the error. +*/ +XMLPARSEAPI(enum XML_Error) +XML_GetErrorCode(XML_Parser parser); + +/* These functions return information about the current parse + location. They may be called from any callback called to report + some parse event; in this case the location is the location of the + first of the sequence of characters that generated the event. When + called from callbacks generated by declarations in the document + prologue, the location identified isn't as neatly defined, but will + be within the relevant markup. When called outside of the callback + functions, the position indicated will be just past the last parse + event (regardless of whether there was an associated callback). + + They may also be called after returning from a call to XML_Parse + or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then + the location is the location of the character at which the error + was detected; otherwise the location is the location of the last + parse event, as described above. +*/ +XMLPARSEAPI(int) XML_GetCurrentLineNumber(XML_Parser parser); +XMLPARSEAPI(int) XML_GetCurrentColumnNumber(XML_Parser parser); +XMLPARSEAPI(long) XML_GetCurrentByteIndex(XML_Parser parser); + +/* Return the number of bytes in the current event. + Returns 0 if the event is in an internal entity. +*/ +XMLPARSEAPI(int) +XML_GetCurrentByteCount(XML_Parser parser); + +/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets + the integer pointed to by offset to the offset within this buffer + of the current parse position, and sets the integer pointed to by size + to the size of this buffer (the number of input bytes). Otherwise + returns a NULL pointer. Also returns a NULL pointer if a parse isn't + active. + + NOTE: The character pointer returned should not be used outside + the handler that makes the call. +*/ +XMLPARSEAPI(const char *) +XML_GetInputContext(XML_Parser parser, + int *offset, + int *size); + +/* For backwards compatibility with previous versions. */ +#define XML_GetErrorLineNumber XML_GetCurrentLineNumber +#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber +#define XML_GetErrorByteIndex XML_GetCurrentByteIndex + +/* Frees the content model passed to the element declaration handler */ +XMLPARSEAPI(void) +XML_FreeContentModel(XML_Parser parser, XML_Content *model); + +/* Exposing the memory handling functions used in Expat */ +XMLPARSEAPI(void *) +XML_MemMalloc(XML_Parser parser, size_t size); + +XMLPARSEAPI(void *) +XML_MemRealloc(XML_Parser parser, void *ptr, size_t size); + +XMLPARSEAPI(void) +XML_MemFree(XML_Parser parser, void *ptr); + +/* Frees memory used by the parser. */ +XMLPARSEAPI(void) +XML_ParserFree(XML_Parser parser); + +/* Returns a string describing the error. */ +XMLPARSEAPI(const XML_LChar *) +XML_ErrorString(enum XML_Error code); + +/* Return a string containing the version number of this expat */ +XMLPARSEAPI(const XML_LChar *) +XML_ExpatVersion(void); + +typedef struct { + int major; + int minor; + int micro; +} XML_Expat_Version; + +/* Return an XML_Expat_Version structure containing numeric version + number information for this version of expat. +*/ +XMLPARSEAPI(XML_Expat_Version) +XML_ExpatVersionInfo(void); + +/* Added in Expat 1.95.5. */ +enum XML_FeatureEnum { + XML_FEATURE_END = 0, + XML_FEATURE_UNICODE, + XML_FEATURE_UNICODE_WCHAR_T, + XML_FEATURE_DTD, + XML_FEATURE_CONTEXT_BYTES, + XML_FEATURE_MIN_SIZE, + XML_FEATURE_SIZEOF_XML_CHAR, + XML_FEATURE_SIZEOF_XML_LCHAR + /* Additional features must be added to the end of this enum. */ +}; + +typedef struct { + enum XML_FeatureEnum feature; + const XML_LChar *name; + long int value; +} XML_Feature; + +XMLPARSEAPI(const XML_Feature *) +XML_GetFeatureList(void); + + +/* Expat follows the GNU/Linux convention of odd number minor version for + beta/development releases and even number minor version for stable + releases. Micro is bumped with each release, and set to 0 with each + change to major or minor version. +*/ +#define XML_MAJOR_VERSION 1 +#define XML_MINOR_VERSION 95 +#define XML_MICRO_VERSION 7 + +#ifdef __cplusplus +} +#endif + +#endif /* not XmlParse_INCLUDED */ diff --git a/gpsbabel/msvc/Expat/libexpat.dll b/gpsbabel/msvc/Expat/libexpat.dll new file mode 100755 index 0000000000000000000000000000000000000000..4c925de3579d7bc74ea0c85f4d096d0070e09da1 GIT binary patch literal 143360 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

o`}M#~TH!R_w*#*Mmjd$$ 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 Gf%{*geonRk literal 0 HcmV?d00001 diff --git a/gpsbabel/msvc/GPSBabel.dsp b/gpsbabel/msvc/GPSBabel.dsp new file mode 100644 index 000000000..07b501040 --- /dev/null +++ b/gpsbabel/msvc/GPSBabel.dsp @@ -0,0 +1,617 @@ +# Microsoft Developer Studio Project File - Name="GPSBabel" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=GPSBabel - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "GPSBabel.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "GPSBabel.mak" CFG="GPSBabel - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "GPSBabel - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "GPSBabel - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "expat" /I "..\coldsync" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "__WIN32__" /D VERSION=\"1.2.1_beta01072004_msvc\" /YX /FD /c +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "expat" /I "..\coldsync" /D "WIN32" /D "__WIN32__" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D VERSION=\"1.2.1_beta01072004_msvc\" /FR /YX /FD /GZ /c +# SUBTRACT CPP /WX +# ADD BASE RSC /l 0x409 /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "GPSBabel - Win32 Release" +# Name "GPSBabel - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Group "Jeeps" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=..\jeeps\gpsapp.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpscom.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsmath.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsmem.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsprot.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsread.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsrqst.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpssend.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsserial.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsutil.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Jeeps" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Jeeps" + +!ENDIF + +# End Source File +# End Group +# Begin Group "Coldsync" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=..\coldsync\pdb.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Coldsync" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Coldsync" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=..\coldsync\util.c + +!IF "$(CFG)" == "GPSBabel - Win32 Release" + +# PROP Intermediate_Dir "Release\Coldsync" + +!ELSEIF "$(CFG)" == "GPSBabel - Win32 Debug" + +# PROP Intermediate_Dir "Debug\Coldsync" + +!ENDIF + +# End Source File +# End Group +# Begin Source File + +SOURCE=..\arcdist.c +# End Source File +# Begin Source File + +SOURCE=..\cetus.c +# End Source File +# Begin Source File + +SOURCE=..\copilot.c +# End Source File +# Begin Source File + +SOURCE=..\csv_util.c +# End Source File +# Begin Source File + +SOURCE=..\delgpl.c +# End Source File +# Begin Source File + +SOURCE=..\duplicate.c +# End Source File +# Begin Source File + +SOURCE=..\easygps.c +# End Source File +# Begin Source File + +SOURCE=..\filter_vecs.c +# End Source File +# Begin Source File + +SOURCE=..\garmin.c +# End Source File +# Begin Source File + +SOURCE=..\gcdb.c +# End Source File +# Begin Source File + +SOURCE=..\geo.c +# End Source File +# Begin Source File + +SOURCE=..\geoniche.c +# End Source File +# Begin Source File + +SOURCE=..\gpilots.c +# End Source File +# Begin Source File + +SOURCE=..\gpsdrive.c +# End Source File +# Begin Source File + +SOURCE=..\gpspilot.c +# End Source File +# Begin Source File + +SOURCE=..\gpsutil.c +# End Source File +# Begin Source File + +SOURCE=..\gpx.c +# End Source File +# Begin Source File + +SOURCE=..\grtcirc.c +# End Source File +# Begin Source File + +SOURCE=..\holux.c +# End Source File +# Begin Source File + +SOURCE=..\internal_styles.c +# End Source File +# Begin Source File + +SOURCE=..\magnav.c +# End Source File +# Begin Source File + +SOURCE=..\magproto.c +# End Source File +# Begin Source File + +SOURCE=..\main.c +# End Source File +# Begin Source File + +SOURCE=..\mapopolis.c +# End Source File +# Begin Source File + +SOURCE=..\mapsend.c +# End Source File +# Begin Source File + +SOURCE=..\mapsource.c +# End Source File +# Begin Source File + +SOURCE=..\mkshort.c +# End Source File +# Begin Source File + +SOURCE=..\navicache.c +# End Source File +# Begin Source File + +SOURCE=..\ozi.c +# End Source File +# Begin Source File + +SOURCE=..\pcx.c +# End Source File +# Begin Source File + +SOURCE=..\polygon.c +# End Source File +# Begin Source File + +SOURCE=..\position.c +# End Source File +# Begin Source File + +SOURCE=..\psitrex.c +# End Source File +# Begin Source File + +SOURCE=..\psp.c +# End Source File +# Begin Source File + +SOURCE=..\queue.c +# End Source File +# Begin Source File + +SOURCE=..\quovadis.c +# End Source File +# Begin Source File + +SOURCE=..\reverse_route.c +# End Source File +# Begin Source File + +SOURCE=..\route.c +# End Source File +# Begin Source File + +SOURCE=..\saroute.c +# End Source File +# Begin Source File + +SOURCE=..\smplrout.c +# End Source File +# Begin Source File + +SOURCE=..\tiger.c +# End Source File +# Begin Source File + +SOURCE=..\tmpro.c +# End Source File +# Begin Source File + +SOURCE=..\tpg.c +# End Source File +# Begin Source File + +SOURCE=..\util.c +# End Source File +# Begin Source File + +SOURCE=..\vecs.c +# End Source File +# Begin Source File + +SOURCE=..\vmem.c +# End Source File +# Begin Source File + +SOURCE=..\waypt.c +# End Source File +# Begin Source File + +SOURCE=..\xcsv.c +# End Source File +# Begin Source File + +SOURCE=.\Expat\libexpat.lib +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Group "Coldsync-Headers" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=..\coldsync\config.h +# End Source File +# Begin Source File + +SOURCE=..\coldsync\palm.h +# End Source File +# Begin Source File + +SOURCE=..\coldsync\pdb.h +# End Source File +# Begin Source File + +SOURCE=..\coldsync\pconn\util.h +# End Source File +# End Group +# Begin Group "Jeeps-Headers" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=..\jeeps\gps.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsapp.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpscom.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsdatum.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsfmt.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsinput.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsmath.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsmem.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsnmea.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsnmeafmt.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsnmeaget.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsport.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsproj.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsprot.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsread.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsrqst.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpssend.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsserial.h +# End Source File +# Begin Source File + +SOURCE=..\jeeps\gpsutil.h +# End Source File +# End Group +# Begin Source File + +SOURCE=..\csv_util.h +# End Source File +# Begin Source File + +SOURCE=..\defs.h +# End Source File +# Begin Source File + +SOURCE=..\garmin_tables.h +# End Source File +# Begin Source File + +SOURCE=..\grtcirc.h +# End Source File +# Begin Source File + +SOURCE=..\holux.h +# End Source File +# Begin Source File + +SOURCE=..\magellan.h +# End Source File +# Begin Source File + +SOURCE=..\mapsend.h +# End Source File +# Begin Source File + +SOURCE=..\queue.h +# End Source File +# Begin Source File + +SOURCE=..\quovadis.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# End Target +# End Project diff --git a/gpsbabel/msvc/GPSBabel.dsw b/gpsbabel/msvc/GPSBabel.dsw new file mode 100644 index 000000000..622d699e8 --- /dev/null +++ b/gpsbabel/msvc/GPSBabel.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "GPSBabel"=.\GPSBabel.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + -- 2.30.2